"""
计算工时的算法

需求：
由于每次需要将工时完全分配完，在不同等级的工时分配中以何种比例分配就是需要解决的问题。
以前我们就是通过Excel不断的调节，但是这种方式不容易找到最佳的比例，通过此程序将最佳比例的所有可能性找出。

算法思想：
本算法并不是一个优化后的算法，做了一些无用的计算，但最终达到了目的。
本算法将每一个等级的工时最大值作为进位制的，然后通过商和余数来控制每个等级可能分配的值，进行全遍历。
使用算法的好处是用时间换空间，避免了使用多个for循环嵌套，而且一旦有一个新的等级，就需要修改源码，增加一个for循环
利用算法只需要将新的等级加入到初始化数据中，算法会自动计算
"""
class MaxWorkHour:
    def __init__(self):
        self.currentV = 0
        self.maxV = 0

    # 给Key做一个排序，并且形成一个list
    def listCoefficient(self, dictCoefficientNum):
        listCoe = []
        for (k, v) in dictCoefficientNum.items():
            if (v > 1):
                listCoe.append(k)
        return listCoe


    # 从list中提取每个Key，并形成系数和除数的字典
    def mapCoefficientDivisor(self, dictCoefficientNum, listCoefficient):
        dictCoeDiv = {}
        dictCoeDiv[listCoefficient[0]] = dictCoefficientNum[listCoefficient[0]]
        divisor = dictCoefficientNum[listCoefficient[0]]
        for i in range(1, len(listCoefficient)):
            coeffient = listCoefficient[i]
            dictCoeDiv[coeffient] = divisor * dictCoefficientNum[coeffient]
            divisor = dictCoeDiv[coeffient]
        return dictCoeDiv


    # 获取list中的每个最大值，并计算被除数的最大值
    def maxDivident(self, dictCoefficientNum, listCoefficient):
        maxValue = 1
        for k in listCoefficient:
            maxValue = maxValue * dictCoefficientNum[k]
        return maxValue

    # 根据被除数、除数，获得每个进制阶段的商、余数
    def calculateValue(self, divident, divisor, coefficient):
        quotien = divident // divisor
        remainder = divident % divisor
        product = remainder * coefficient
        return quotien, remainder, product


    # for循环所有的值，并按照list的顺序进行整除，余数作为乘以对应系数的值，商则进行下一个整除
    # 完成整除后，求和，判断如果小于界限值，且大于上一个最大值，则保留所有的商，形成系数：商，否则进行下一次循环
    def maxValueWorkHour(self, dictCoefficientNum, constraintValue):
        list_coefficient = self.listCoefficient(dictCoefficientNum)
        # map_coefficient_divisor = mapCoefficientDivisor(dictCoefficientNum, list_coefficient)
        map_coefficient_divisor = dictCoefficientNum.copy()
        max_divident = self.maxDivident(dictCoefficientNum, list_coefficient)
        max_result_list = []
        max_result = {}
        max_sum = 0
        self.maxV = max_divident
        for divident in range(1, max_divident):
            self.currentV = divident
            sum_work_hour = 0
            temp_result = {}
            temp_divident = divident
            for k in list_coefficient:
                q, r, p = self.calculateValue(temp_divident, map_coefficient_divisor[k], k)
                temp_divident = q
                temp_result[k] = r
                sum_work_hour += k * r
            if constraintValue >= sum_work_hour >= max_sum:
                max_result = temp_result
                max_sum = sum_work_hour
                if constraintValue == int(max_sum):
                    max_result_list.append(max_result)
        if len(max_result_list) == 0:
            return max_sum, max_result
        else:
            return max_sum, max_result_list


if __name__ == '__main__':
    # start = time.time()
    # dict_work_hour = {0.94: 46, 0.85: 22, 1.15: 66, 0.73: 22, 0.2: 20}
    # max_sum, max_result = maxValueWorkHour(dict_work_hour, 120)
    # end = time.time()
    # print(max_sum)
    # print(max_result)
    # print("运算耗时：", end-start)
    listPeople = []
    print(isinstance(listPeople, dict))
